/*
 * Intel ACPI Component Architecture
 * AML/ASL+ Disassembler version 20141107-64 [Jan  2 2015]
 * Copyright (c) 2000 - 2014 Intel Corporation
 * 
 * Disassembling to non-symbolic legacy ASL operators
 *
 * Disassembly of SSDT-4.aml, Thu Nov 12 23:08:04 2015
 *
 * Original Table Header:
 *     Signature        "SSDT"
 *     Length           0x00000DAE (3502)
 *     Revision         0x01
 *     Checksum         0x7A
 *     OEM ID           "NvORef"
 *     OEM Table ID     "NvOptTbl"
 *     OEM Revision     0x00001000 (4096)
 *     Compiler ID      "INTL"
 *     Compiler Version 0x20061109 (537268489)
 */
DefinitionBlock ("SSDT-4.aml", "SSDT", 1, "NvORef", "NvOptTbl", 0x00001000)
{

    External (_PR_.CPU0, ProcessorObj)
    External (_PR_.CPU0._PPC, IntObj)
    External (_PR_.CPU0._PSS, PkgObj)
    External (_SB_.PCI0.IGPU, DeviceObj)
    External (_SB_.PCI0.LPCB.EC0_.DTS1, FieldUnitObj)
    External (_SB_.PCI0.PEG0.PEGP, DeviceObj)
    External (_SB_.PCI0.PEG0.PEGP._ADR, IntObj)
    External (_SB_.PHSR, MethodObj)    // 1 Arguments
    External (BRID, FieldUnitObj)
    External (MSRC, FieldUnitObj)
    External (NVHA, FieldUnitObj)
    External (P8XH, MethodObj)    // 2 Arguments

    Scope (\_SB.PCI0.PEG0.PEGP)
    {
        OperationRegion (GPIO, SystemIO, 0x0500, 0x60)
        Field (GPIO, ByteAcc, Lock, Preserve)
        {
            Offset (0x0C), 
                ,   3, 
                ,   1, 
            Offset (0x0E), 
                ,   1, 
            DGPG,   1, 
                ,   4, 
            DGVR,   1, 
            Offset (0x31), 
                ,   7, 
            DCQU,   1, 
            Offset (0x35), 
                ,   7, 
            DCQS,   1, 
            Offset (0x38), 
                ,   7, 
            Offset (0x39), 
                ,   7, 
            DCQV,   1, 
                ,   2, 
            DGRS,   1, 
                ,   1, 
                ,   1, 
                ,   1, 
            DGPW,   1
        }

        Method (OPON, 0, NotSerialized)
        {
            Store (Zero, DGRS)
            Sleep (0x64)
            Store (One, DGPW)
            Sleep (0x69)
            Store (One, DCQU)
            Store (Zero, DCQS)
            Store (Zero, DCQV)
            Sleep (0x05)
            If (LEqual (DGPG, One))
            {
                P8XH (Zero, 0x21)
            }

            Store (Zero, DQDA)
            Store (One, DGRS)
            Store (Zero, DCQU)
            Sleep (0x64)
            Store (Zero, LNKD)
            While (LLess (LNKS, 0x07))
            {
                Sleep (One)
            }

            If (LEqual (SETF, One))
            {
                Store (VGAB, VGAR)
            }
        }

        Method (OPOF, 0, NotSerialized)
        {
            Store (One, LCRB)
            Store (One, DQDA)
            Store (Zero, LCRB)
            Store (VGAR, VGAB)
            Store (One, SETF)
            Store (One, LNKD)
            While (LGreater (LNKS, Zero))
            {
                Sleep (One)
            }

            Store (Zero, DGRS)
            Sleep (0x64)
            Store (Zero, DGPW)
            Sleep (0x64)
            If (LEqual (DGPG, Zero))
            {
                P8XH (Zero, 0x31)
            }
        }
    }

    Scope (\_SB.PCI0.PEG0.PEGP)
    {
        Name (DGOS, Zero)
        Name (SETF, Zero)
        Name (OMPR, 0x02)
        Name (_PSC, Zero)  // _PSC: Power State Current
        OperationRegion (VGAM, SystemMemory, 0xF8100000, 0x0100)
        Field (VGAM, DWordAcc, NoLock, Preserve)
        {
            VGAR,   2048
        }

        OperationRegion (PEGM, SystemMemory, 0xF8008000, 0x0FF0)
        Field (PEGM, ByteAcc, NoLock, Preserve)
        {
            REG0,   32, 
            REG1,   32, 
            REG2,   32, 
            Offset (0x19), 
            RE19,   8, 
            RE1A,   8, 
            Offset (0x3E), 
            RE3E,   8, 
            Offset (0x84), 
            PWST,   2, 
            Offset (0xB0), 
            ASPM,   2, 
                ,   2, 
            LNKD,   1, 
            Offset (0xB3), 
                ,   3, 
            LTST,   1, 
            RSCC,   1, 
            Offset (0xB4), 
                ,   6, 
            HPCP,   1, 
            SPLV,   8, 
            SPLS,   2, 
                ,   2, 
            PHSN,   13, 
            HPD,    8, 
            Offset (0x114), 
            T0V0,   1, 
            TV0M,   7, 
            Offset (0x1FC), 
            R1FC,   9, 
            Offset (0x201), 
                ,   5, 
            CGEL,   2, 
                ,   3, 
            LCRB,   1, 
            Offset (0x204), 
            RETO,   10, 
            Offset (0x214), 
            Offset (0x216), 
            LNKS,   4, 
            Offset (0x220), 
            R220,   32, 
            Offset (0x225), 
            DQDA,   1, 
            Offset (0x226), 
            R224,   32, 
            Offset (0xC28), 
            RC28,   1, 
            Offset (0xC34), 
            RC34,   32, 
            Offset (0xDFC), 
                ,   1, 
            RDFC,   3, 
            Offset (0xE08), 
            Offset (0xE0B), 
                ,   6, 
            RE08,   1, 
            Offset (0xE28), 
            Offset (0xE2B), 
                ,   6, 
            RE28,   1, 
            Offset (0xE48), 
            Offset (0xE4B), 
                ,   6, 
            RE48,   1, 
            Offset (0xE68), 
            Offset (0xE6B), 
                ,   6, 
            RE68,   1, 
            Offset (0xE88), 
            Offset (0xE8B), 
                ,   6, 
            RE88,   1, 
            Offset (0xEA8), 
            Offset (0xEAB), 
                ,   6, 
            REA8,   1, 
            Offset (0xEC8), 
            Offset (0xECB), 
                ,   6, 
            REC8,   1, 
            Offset (0xEE8), 
            Offset (0xEEB), 
                ,   6, 
            REE8,   1, 
            Offset (0xF08), 
            Offset (0xF0B), 
                ,   6, 
            RF08,   1, 
            Offset (0xF28), 
            Offset (0xF2B), 
                ,   6, 
            RF28,   1, 
            Offset (0xF48), 
            Offset (0xF4B), 
                ,   6, 
            RF48,   1, 
            Offset (0xF68), 
            Offset (0xF6B), 
                ,   6, 
            RF68,   1, 
            Offset (0xF88), 
            Offset (0xF8B), 
                ,   6, 
            RF88,   1, 
            Offset (0xFA8), 
            Offset (0xFAB), 
                ,   6, 
            RFA8,   1, 
            Offset (0xFC8), 
            Offset (0xFCB), 
                ,   6, 
            RFC8,   1, 
            Offset (0xFE8), 
            Offset (0xFEB), 
                ,   6, 
            RFE8,   1
        }

        OperationRegion (NVHM, SystemMemory, NVHA, 0x00020400)
        Field (NVHM, AnyAcc, NoLock, Preserve)
        {
            NVSG,   128, 
            NVSZ,   32, 
            NVVR,   32, 
            Offset (0x100), 
            NVHO,   32, 
            RVBS,   32, 
            Offset (0x180), 
            TNDI,   8, 
            DGND,   8, 
            IGND,   8, 
            Offset (0x190), 
            Offset (0x1B0), 
            DDI1,   32, 
            DDI2,   32, 
            DDI3,   32, 
            DDI4,   32, 
            DDI5,   32, 
            DDI6,   32, 
            DDI7,   32, 
            DDI8,   32, 
            Offset (0x200), 
            Offset (0x220), 
            Offset (0x240), 
            Offset (0x260), 
            DCP1,   32, 
            DCP2,   32, 
            DCP3,   32, 
            DCP4,   32, 
            DCP5,   32, 
            DCP6,   32, 
            DCP7,   32, 
            DCP8,   32, 
            DCA1,   32, 
            DCA2,   32, 
            DCA3,   32, 
            DCA4,   32, 
            DCA5,   32, 
            DCA6,   32, 
            DCA7,   32, 
            DCA8,   32, 
            DNA1,   32, 
            DNA2,   32, 
            DNA3,   32, 
            DNA4,   32, 
            DNA5,   32, 
            DNA6,   32, 
            DNA7,   32, 
            DNA8,   32, 
            Offset (0x3C0), 
            RAPM,   8, 
            EAPM,   8, 
            TSLC,   16, 
            DNDI,   8, 
            Offset (0x400), 
            RBF1,   262144, 
            RBF2,   262144, 
            RBF3,   262144, 
            RBF4,   262144
        }

        OperationRegion (PCNV, SystemMemory, 0xF8100488, 0x04)
        Field (PCNV, ByteAcc, NoLock, Preserve)
        {
                ,   25, 
            MLTF,   1
        }

        Name (VGAB, Buffer (0x0100)
        {
            /* 0000 */  0xDE, 0x10, 0x29, 0x0A, 0x06, 0x01, 0x10, 0x00,
            /* 0008 */  0xA2, 0x00, 0x00, 0x03, 0x10, 0x00, 0x00, 0x00,
            /* 0010 */  0x00, 0x00, 0x00, 0xAC, 0x0C, 0x00, 0x00, 0xB0,
            /* 0018 */  0x00, 0x00, 0x00, 0x00, 0x0C, 0x00, 0x00, 0xAE,
            /* 0020 */  0x00, 0x00, 0x00, 0x00, 0x81, 0x2C, 0x00, 0x00,
            /* 0028 */  0x00, 0x00, 0x00, 0x00, 0x28, 0x10, 0x6E, 0x04,
            /* 0030 */  0x00, 0x00, 0x00, 0x00, 0x60, 0x00, 0x00, 0x00,
            /* 0038 */  0x00, 0x00, 0x00, 0x00, 0x10, 0x01, 0x00, 0x00,
            /* 0040 */  0x28, 0x10, 0x6E, 0x04, 0x00, 0x00, 0x00, 0x00,
            /* 0048 */  0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
            /* 0050 */  0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
            /* 0058 */  0xCE, 0xD6, 0x23, 0x00, 0x00, 0x00, 0x00, 0x00,
            /* 0060 */  0x01, 0x68, 0x03, 0x00, 0x08, 0x00, 0x00, 0x00,
            /* 0068 */  0x05, 0x78, 0x80, 0x00, 0x00, 0x00, 0x00, 0x00,
            /* 0070 */  0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
            /* 0078 */  0x10, 0xB4, 0x02, 0x00, 0xE0, 0x8D, 0x2C, 0x01,
            /* 0080 */  0x10, 0x29, 0x00, 0x00, 0x02, 0x2D, 0x06, 0x00,
            /* 0088 */  0x4B, 0x01, 0x01, 0x11, 0x00, 0x00, 0x00, 0x00,
            /* 0090 */  0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
            /* 0098 */  0x00, 0x00, 0x00, 0x00, 0x10, 0x00, 0x00, 0x00,
            /* 00A0 */  0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
            /* 00A8 */  0x02, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
            /* 00B0 */  0x00, 0x00, 0x00, 0x00, 0x09, 0x00, 0x14, 0x01,
            /* 00B8 */  0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
            /* 00C0 */  0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
            /* 00C8 */  0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
            /* 00D0 */  0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
            /* 00D8 */  0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
            /* 00E0 */  0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
            /* 00E8 */  0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
            /* 00F0 */  0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
            /* 00F8 */  0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 
        })
        Method (_INI, 0, NotSerialized)  // _INI: Initialize
        {
            If (LNotEqual (BRID, 0x06))
            {
                Store (Zero, \_SB.PCI0.PEG0.PEGP._ADR)
            }
        }

        Method (_PS0, 0, NotSerialized)  // _PS0: Power State 0
        {
            If (LNotEqual (BRID, 0x06))
            {
                P8XH (Zero, 0xF0)
                Store (Zero, _PSC)
                If (DGOS)
                {
                    P8XH (Zero, 0xF1)
                    OPON ()
                    Sleep (0x64)
                    PHSR (0xB6)
                    Store (Zero, DGOS)
                }
            }
        }

        Method (_PS3, 0, NotSerialized)  // _PS3: Power State 3
        {
            If (LNotEqual (BRID, 0x06))
            {
                P8XH (Zero, 0xF2)
                If (LEqual (OMPR, 0x03))
                {
                    P8XH (Zero, 0xF3)
                    OPOF ()
                    Store (One, DGOS)
                    Store (0x02, OMPR)
                    Store (0x03, _PSC)
                }
            }
        }

        Method (_IRC, 0, NotSerialized){}
        //Name (_IRC, Zero)  // _IRC: Inrush Current
        Method (_ROM, 2, NotSerialized)  // _ROM: Read-Only Memory
        {
            Store (Arg0, Local0)
            Store (Arg1, Local1)
            If (LGreater (Local1, 0x1000))
            {
                Store (0x1000, Local1)
            }

            If (LGreater (Local0, 0x00020000))
            {
                Return (Buffer (Local1)
                {
                     0x00                                           
                })
            }

            If (LGreater (Local0, RVBS))
            {
                Return (Buffer (Local1)
                {
                     0x00                                           
                })
            }

            Multiply (Local1, 0x08, Local3)
            Name (ROM1, Buffer (0x8000)
            {
                 0x00                                           
            })
            Name (ROM2, Buffer (Local1)
            {
                 0x00                                           
            })
            If (LLess (Local0, 0x8000))
            {
                Store (RBF1, ROM1)
            }
            Else
            {
                If (LLess (Local0, 0x00010000))
                {
                    Subtract (Local0, 0x8000, Local0)
                    Store (RBF2, ROM1)
                }
                Else
                {
                    If (LLess (Local0, 0x00018000))
                    {
                        Subtract (Local0, 0x00010000, Local0)
                        Store (RBF3, ROM1)
                    }
                    Else
                    {
                        Subtract (Local0, 0x00018000, Local0)
                        Store (RBF4, ROM1)
                    }
                }
            }

            Multiply (Local0, 0x08, Local2)
            CreateField (ROM1, Local2, Local3, TMPB)
            Store (TMPB, ROM2)
            Return (ROM2)
        }
    }

    Scope (\_SB.PCI0.IGPU)
    {
        OperationRegion (IGDV, PCI_Config, Zero, 0x04)
        Field (IGDV, AnyAcc, NoLock, Preserve)
        {
            IGDD,   32
        }

        Method (_DSM, 4, Serialized)  // _DSM: Device-Specific Method
        {
            P8XH (Zero, 0xF5)
            If (LEqual (Arg0, ToUUID ("7ed873d3-c2d0-4e4f-a854-0f1317b01c2c")))
            {
                Return (One)
            }
            Else
            {
                Return (\_SB.PCI0.PEG0.PEGP._DSM (Arg0, Arg1, Arg2, Arg3))
            }
        }
    }

    Scope (\_SB.PCI0.PEG0.PEGP)
    {
        Name (PSCP, Zero)
        Name (GPSD, Buffer (0x24) {})
        CreateDWordField (GPSD, Zero, RETN)
        CreateDWordField (GPSD, 0x04, VRV1)
        CreateDWordField (GPSD, 0x08, TGPU)
        CreateDWordField (GPSD, 0x0C, PDTS)
        CreateDWordField (GPSD, 0x10, SFAN)
        CreateDWordField (GPSD, 0x14, SKNT)
        CreateDWordField (GPSD, 0x18, CPUE)
        CreateDWordField (GPSD, 0x1C, TMP1)
        CreateDWordField (GPSD, 0x20, TMP2)
        Method (_DSM, 4, NotSerialized)  // _DSM: Device-Specific Method
        {
            If (LEqual (Arg0, ToUUID ("a486d8f8-0bda-471b-a72b-6042a6b5bee0")))
            {
                P8XH (Zero, 0xF5)
                Return (NVOP (Arg0, Arg1, Arg2, Arg3))
            }

            If (LEqual (Arg0, ToUUID ("a3132d01-8cda-49ba-a52e-bc9d46df6b81")))
            {
                P8XH (Zero, 0xE4)
                Return (GPS (Arg0, Arg1, Arg2, Arg3))
            }
        }

        Method (NVOP, 4, NotSerialized)
        {
            P8XH (Zero, 0xF6)
            If (LNotEqual (Arg1, 0x0100))
            {
                P8XH (Zero, 0xFA)
                Return (0x80000001)
            }

            P8XH (Zero, 0xF7)
            If (LEqual (Arg2, Zero))
            {
                P8XH (Zero, 0xF8)
                Store (Buffer (0x04)
                    {
                         0x00, 0x00, 0x00, 0x00                         
                    }, Local0)
                Divide (Zero, 0x08, Local2, Local1)
                ShiftLeft (One, Local2, Local2)
                Or (DerefOf (Index (Local0, Local1)), Local2, Index (Local0, Local1))
                Divide (0x1A, 0x08, Local2, Local1)
                ShiftLeft (One, Local2, Local2)
                Or (DerefOf (Index (Local0, Local1)), Local2, Index (Local0, Local1))
                Divide (0x1B, 0x08, Local2, Local1)
                ShiftLeft (One, Local2, Local2)
                Or (DerefOf (Index (Local0, Local1)), Local2, Index (Local0, Local1))
                Divide (0x05, 0x08, Local2, Local1)
                ShiftLeft (One, Local2, Local2)
                Or (DerefOf (Index (Local0, Local1)), Local2, Index (Local0, Local1))
                Return (Local0)
            }

            If (LEqual (Arg2, 0x05))
            {
                P8XH (Zero, 0xE5)
                Return (0x00300000)
            }

            If (LEqual (Arg2, 0x1A))
            {
                P8XH (Zero, 0xF9)
                CreateField (Arg3, 0x18, 0x02, OPCE)
                CreateField (Arg3, Zero, One, FLCH)
                If (ToInteger (FLCH))
                {
                    Store (OPCE, OMPR)
                }

                Store (Buffer (0x04)
                    {
                         0x00, 0x00, 0x00, 0x00                         
                    }, Local0)
                CreateField (Local0, Zero, One, OPEN)
                CreateField (Local0, 0x03, 0x02, CGCS)
                CreateField (Local0, 0x06, One, SHPC)
                CreateField (Local0, 0x07, One, MDAC)
                CreateField (Local0, 0x18, 0x03, DGPC)
                CreateField (Local0, 0x1B, 0x02, HDAC)
                Store (One, OPEN)
                Store (One, SHPC)
                Store (One, DGPC)
                Store (Zero, MDAC)
                Store (Zero, HDAC)
                If (LEqual (DGPW, One))
                {
                    Store (0x03, CGCS)
                }

                Return (Local0)
            }

            If (LEqual (Arg2, 0x1B))
            {
                P8XH (Zero, 0xF5)
                Store (Buffer (0x04)
                    {
                         0x00, 0x00, 0x00, 0x00                         
                    }, Local0)
                Return (Local0)
            }

            If (LEqual (Arg2, 0x10)) {}
            Return (0x80000002)
        }

        Method (GPS, 4, NotSerialized)
        {
            Name (_T_1, Zero)  // _T_x: Emitted by ASL Compiler
            Name (_T_0, Zero)  // _T_x: Emitted by ASL Compiler
            If (LNotEqual (Arg1, 0x0100))
            {
                P8XH (Zero, 0xFA)
                Return (0x80000002)
            }

            Store (ToInteger (Arg2), _T_0)
            If (LEqual (_T_0, Zero))
            {
                Name (FMSK, Buffer (0x08)
                {
                     0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF 
                })
                Store (Buffer (0x08)
                    {
                         0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 
                    }, Local0)
                Divide (Zero, 0x08, Local2, Local1)
                ShiftLeft (One, Local2, Local2)
                Or (DerefOf (Index (Local0, Local1)), Local2, Index (Local0, Local1))
                Divide (0x13, 0x08, Local2, Local1)
                ShiftLeft (One, Local2, Local2)
                Or (DerefOf (Index (Local0, Local1)), Local2, Index (Local0, Local1))
                Divide (0x20, 0x08, Local2, Local1)
                ShiftLeft (One, Local2, Local2)
                Or (DerefOf (Index (Local0, Local1)), Local2, Index (Local0, Local1))
                Divide (0x21, 0x08, Local2, Local1)
                ShiftLeft (One, Local2, Local2)
                Or (DerefOf (Index (Local0, Local1)), Local2, Index (Local0, Local1))
                Divide (0x22, 0x08, Local2, Local1)
                ShiftLeft (One, Local2, Local2)
                Or (DerefOf (Index (Local0, Local1)), Local2, Index (Local0, Local1))
                Divide (0x23, 0x08, Local2, Local1)
                ShiftLeft (One, Local2, Local2)
                Or (DerefOf (Index (Local0, Local1)), Local2, Index (Local0, Local1))
                Divide (0x2A, 0x08, Local2, Local1)
                ShiftLeft (One, Local2, Local2)
                Or (DerefOf (Index (Local0, Local1)), Local2, Index (Local0, Local1))
                Store (SizeOf (Local0), Local1)
                While (LNotEqual (Local1, Zero))
                {
                    Decrement (Local1)
                    Store (DerefOf (Index (FMSK, Local1)), Local2)
                    And (DerefOf (Index (Local0, Local1)), Local2, Index (Local0, Local1))
                }

                Return (Local0)
            }
            Else
            {
                If (LEqual (_T_0, 0x13))
                {
                    Store (Arg3, Local0)
                    Store (Buffer (0x04)
                        {
                             0x00, 0x00, 0x00, 0x00                         
                        }, Local1)
                    CreateBitField (Local1, 0x02, PSTE)
                    Store (One, PSTE)
                    If (LNotEqual (Local0, Zero))
                    {
                        PHSR (0xB7)
                    }

                    Return (Local1)
                }
                Else
                {
                    If (LEqual (_T_0, 0x20))
                    {
                        Name (RET1, Zero)
                        CreateBitField (Arg3, 0x18, NRIT)
                        CreateBitField (Arg3, 0x19, NRIS)
                        If (NRIS)
                        {
                            If (NRIT)
                            {
                                Or (RET1, 0x01000000, RET1)
                            }
                        }
                        Else
                        {
                            And (RET1, 0xFEFFFFFF, RET1)
                        }

                        Or (RET1, 0x40000000, RET1)
                        Return (RET1)
                    }
                    Else
                    {
                        If (LEqual (_T_0, 0x21))
                        {
                            Return (\_PR.CPU0._PSS)
                        }
                        Else
                        {
                            If (LEqual (_T_0, 0x22))
                            {
                                CreateByteField (Arg3, Zero, PACP)
                                Store (PACP, PSCP)
                                Store (PACP, \_PR.CPU0._PPC)
                                If (LEqual (MSRC, 0x02))
                                {
                                    Notify (\_PR.CPU0, 0x80)
                                }

                                If (LEqual (MSRC, 0x04))
                                {
                                    Notify (\_PR.CPU0, 0x80)
                                }
                            }
                            Else
                            {
                                If (LEqual (_T_0, 0x23))
                                {
                                    Return (PSCP)
                                }
                                Else
                                {
                                    If (LEqual (_T_0, 0x2A))
                                    {
                                        CreateByteField (Arg3, Zero, PSH0)
                                        CreateByteField (Arg3, One, PSH1)
                                        CreateBitField (Arg3, 0x08, GPUT)
                                        CreateBitField (Arg3, 0x09, CPUT)
                                        CreateBitField (Arg3, 0x0A, FANS)
                                        CreateBitField (Arg3, 0x0B, SKIN)
                                        CreateBitField (Arg3, 0x0C, ENGR)
                                        CreateBitField (Arg3, 0x0D, SEN1)
                                        CreateBitField (Arg3, 0x0E, SEN2)
                                        Store (0x00010000, VRV1)
                                        Store (ToInteger (PSH0), _T_1)
                                        If (LEqual (_T_1, Zero))
                                        {
                                            If (CPUT)
                                            {
                                                Store (0x0200, RETN)
                                                Or (RETN, PSH0, RETN)
                                                Store (\_SB.PCI0.LPCB.EC0.DTS1, PDTS)
                                            }

                                            Return (GPSD)
                                        }
                                        Else
                                        {
                                            If (LEqual (_T_1, One))
                                            {
                                                Store (0x0300, RETN)
                                                Or (RETN, PSH0, RETN)
                                                Store (0x03E8, PDTS)
                                                Store (0x03E8, TGPU)
                                                Return (GPSD)
                                            }
                                            Else
                                            {
                                                If (LEqual (_T_1, 0x02))
                                                {
                                                    Or (RETN, PSH1, RETN)
                                                    ShiftLeft (RETN, 0x08, RETN)
                                                    Or (RETN, PSH0, RETN)
                                                    Store (0x0102, RETN)
                                                    If (LEqual (BRID, One))
                                                    {
                                                        Store (0x5A, TGPU)
                                                    }
                                                    Else
                                                    {
                                                        If (LEqual (BRID, 0x04))
                                                        {
                                                            Store (0x58, TGPU)
                                                        }
                                                        Else
                                                        {
                                                            If (LEqual (BRID, 0x05))
                                                            {
                                                                Store (0x5B, TGPU)
                                                            }
                                                        }
                                                    }

                                                    Store (Zero, PDTS)
                                                    Store (Zero, SFAN)
                                                    Store (Zero, CPUE)
                                                    Store (Zero, SKNT)
                                                    Store (Zero, TMP1)
                                                    Store (Zero, TMP2)
                                                    Return (GPSD)
                                                }
                                            }
                                        }
                                    }
                                }
                            }
                        }
                    }
                }
            }

            Return (0x80000002)
        }
    }
}

